#ifndef CLINK_ROUTER_ROUTER_H
#define CLINK_ROUTER_ROUTER_H

#include "IRouteHandler.h"
#include "BaseRouteHandler.h"
#include "RegexRouteHandler.h"
#include "StandardRouteHandler.h"
#include "../error/ErrorHandler.h"
#include "../Utils/Utils.h"
#include "../Utils/ResponseUtils.h"
#include "../database/DatabaseManager.h"

#include <vector>
#include <memory>
#include <string>
#include <functional>
#include <mutex>

#include <Poco/Logger.h>

namespace CLink
{
namespace Router
{

/**
 * @brief 中间件处理函数类型
 */
using MiddlewareHandler = std::function<bool(RequestContext &)>;

/**
 * @brief 路由处理函数类型
 */
using RouteHandlerFunc = std::function<void(RequestContext &)>;

/**
 * @brief 路由组类
 *
 * 用于管理具有共同前缀的路由
 */
class CLINK_CLASS RouteGroup
{
public:
    explicit RouteGroup(const std::string &prefix);

    /**
     * @brief 添加路由处理器
     * @param handler 路由处理器
     * @return 当前对象的引用，支持链式调用
     */
    RouteGroup &addHandler(std::shared_ptr<IRouteHandler> handler);

    /**
     * @brief 添加中间件
     * @param middleware 中间件处理函数
     * @return 当前对象的引用，支持链式调用
     */
    RouteGroup &addMiddleware(MiddlewareHandler middleware);

    /**
     * @brief 获取路由前缀
     * @return 路由前缀
     */
    const std::string &getPrefix() const;

    /**
     * @brief 获取路由处理器列表
     * @return 路由处理器列表
     */
    const std::vector<std::shared_ptr<IRouteHandler>> &getHandlers() const;

    /**
     * @brief 获取中间件列表
     * @return 中间件列表
     */
    const std::vector<MiddlewareHandler> &getMiddlewares() const;

    /**
     * @brief 添加GET路由
     * @param path 路由路径(会自动添加组前缀)
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    RouteGroup &Get(const std::string &path, const RouteHandlerFunc &handler, const std::vector<RouteParam>& allow = {})
    {
        auto hand = std::make_shared<StandardRouteHandler>(
            m_prefix + path, Poco::Net::HTTPRequest::HTTP_GET, handler);
        hand->addQueryParam(allow);
        return addHandler(hand);
    }

    /**
     * @brief 添加POST路由
     * @param path 路由路径(会自动添加组前缀)
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    RouteGroup &Post(const std::string &path, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<StandardRouteHandler>(
            m_prefix + path, Poco::Net::HTTPRequest::HTTP_POST, handler));
    }

    /**
     * @brief 添加PUT路由
     * @param path 路由路径(会自动添加组前缀)
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    RouteGroup &Put(const std::string &path, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<StandardRouteHandler>(
            m_prefix + path, Poco::Net::HTTPRequest::HTTP_PUT, handler));
    }

    /**
     * @brief 添加DELETE路由
     * @param path 路由路径(会自动添加组前缀)
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    RouteGroup &Del(const std::string &path, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<StandardRouteHandler>(
            m_prefix + path, Poco::Net::HTTPRequest::HTTP_DELETE, handler));
    }

    /**
     * @brief 添加PATCH路由
     * @param path 路由路径(会自动添加组前缀)
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    RouteGroup &Patch(const std::string &path, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<StandardRouteHandler>(
            m_prefix + path, Poco::Net::HTTPRequest::HTTP_PATCH, handler));
    }

    /**
     * @brief 添加HEAD路由
     * @param path 路由路径(会自动添加组前缀)
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    RouteGroup &Head(const std::string &path, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<StandardRouteHandler>(
            m_prefix + path, Poco::Net::HTTPRequest::HTTP_HEAD, handler));
    }

    /**
     * @brief 添加OPTIONS路由
     * @param path 路由路径(会自动添加组前缀)
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    RouteGroup &Options(const std::string &path, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<StandardRouteHandler>(
            m_prefix + path, Poco::Net::HTTPRequest::HTTP_OPTIONS, handler));
    }

    /**
     * @brief 添加TRACE路由
     * @param path 路由路径(会自动添加组前缀)
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    RouteGroup &Trace(const std::string &path, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<StandardRouteHandler>(
            m_prefix + path, Poco::Net::HTTPRequest::HTTP_TRACE, handler));
    }

    /**
     * @brief 添加GET正则路由
     * @param regex 路由正则表达式(会自动添加组前缀)
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    RouteGroup &RegexGet(const std::string &regex, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<RegexRouteHandler>(
            m_prefix + regex, Poco::Net::HTTPRequest::HTTP_GET, handler));
    }

    /**
     * @brief 添加POST正则路由
     * @param regex 路由正则表达式(会自动添加组前缀)
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    RouteGroup &RegexPost(const std::string &regex, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<RegexRouteHandler>(
            m_prefix + regex, Poco::Net::HTTPRequest::HTTP_POST, handler));
    }

    /**
     * @brief 添加PUT正则路由
     * @param regex 路由正则表达式(会自动添加组前缀)
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    RouteGroup &RegexPut(const std::string &regex, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<RegexRouteHandler>(
            m_prefix + regex, Poco::Net::HTTPRequest::HTTP_PUT, handler));
    }

    /**
     * @brief 添加DELETE正则路由
     * @param regex 路由正则表达式(会自动添加组前缀)
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    RouteGroup &RegexDelete(const std::string &regex, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<RegexRouteHandler>(
            m_prefix + regex, Poco::Net::HTTPRequest::HTTP_DELETE, handler));
    }

    /**
     * @brief 添加PATCH正则路由
     * @param regex 路由正则表达式(会自动添加组前缀)
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    RouteGroup &RegexPatch(const std::string &regex, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<RegexRouteHandler>(
            m_prefix + regex, Poco::Net::HTTPRequest::HTTP_PATCH, handler));
    }

    /**
     * @brief 添加HEAD正则路由
     * @param regex 路由正则表达式(会自动添加组前缀)
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    RouteGroup &RegexHead(const std::string &regex, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<RegexRouteHandler>(
            m_prefix + regex, Poco::Net::HTTPRequest::HTTP_HEAD, handler));
    }

    /**
     * @brief 添加OPTIONS正则路由
     * @param regex 路由正则表达式(会自动添加组前缀)
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    RouteGroup &RegexOptions(const std::string &regex, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<RegexRouteHandler>(
            m_prefix + regex, Poco::Net::HTTPRequest::HTTP_OPTIONS, handler));
    }

    /**
     * @brief 添加TRACE正则路由
     * @param regex 路由正则表达式(会自动添加组前缀)
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    RouteGroup &RegexTrace(const std::string &regex, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<RegexRouteHandler>(
            m_prefix + regex, Poco::Net::HTTPRequest::HTTP_TRACE, handler));
    }

private:
    std::string m_prefix;                                   ///< 路由前缀
    std::vector<std::shared_ptr<IRouteHandler>> m_handlers; ///< 路由处理器列表
    std::vector<MiddlewareHandler> m_middlewares;           ///< 中间件列表
};

/**
 * @brief 路由管理器类
 *
 * 单例模式实现的路由管理器，负责管理所有路由和中间件
 */
    
class CLINK_CLASS Router
{
public:
    void setDBManager(CLink::Db::DatabaseManager::Ptr _db);
	CLink::Db::DatabaseManager::Ptr getDBManager() const { return _dbManager; }

    void setLogger(Poco::Logger& logger);
    /**
     * @brief 添加路由处理器
     * @param handler 路由处理器
     * @return 当前对象的引用，支持链式调用
     */
    Router &addHandler(std::shared_ptr<IRouteHandler> handler);

    /**
     * @brief 添加全局中间件
     * @param middleware 中间件处理函数
     * @return 当前对象的引用，支持链式调用
     */
    Router &addMiddleware(MiddlewareHandler middleware);

    /**
     * @brief 创建路由组
     * @param prefix 路由前缀
     * @return 新创建的路由组
     */
    RouteGroup &group(const std::string &prefix);

    /**
     * @brief 处理HTTP请求
     * @param request Poco HTTP请求对象
     * @param response Poco HTTP响应对象
     */
    void handleRequest(Poco::Net::HTTPServerRequest &request,
                        Poco::Net::HTTPServerResponse &response);

    /**
     * @brief 设置404处理器
     * @param handler 处理器
     */
    void setNotFoundHandler(std::shared_ptr<IRouteHandler> handler);

    /**
     * @brief 设置错误处理器
     * @param handler 处理器
     */
    void setErrorHandler(std::shared_ptr<IRouteHandler> handler);

    /**
     * @brief 添加GET路由
     * @param path 路由路径
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    Router& Get(const std::string& path, const RouteHandlerFunc& handler, const std::vector<RouteParam>& allow = {})
    {
        auto hand =  std::make_shared<StandardRouteHandler>(
            path, Poco::Net::HTTPRequest::HTTP_GET, handler);
        hand->addQueryParam(allow);
        return addHandler(hand);
    }

    /**
     * @brief 添加POST路由
     * @param path 路由路径
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    Router &Post(const std::string &path, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<StandardRouteHandler>(
            path, Poco::Net::HTTPRequest::HTTP_POST, handler));
    }

    /**
     * @brief 添加PUT路由
     * @param path 路由路径
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    Router &Put(const std::string &path, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<StandardRouteHandler>(
            path, Poco::Net::HTTPRequest::HTTP_PUT, handler));
    }

    /**
     * @brief 添加DELETE路由
     * @param path 路由路径
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    Router &Del(const std::string &path, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<StandardRouteHandler>(
            path, Poco::Net::HTTPRequest::HTTP_DELETE, handler));
    }

    /**
     * @brief 添加PATCH路由
     * @param path 路由路径
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    Router &Patch(const std::string &path, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<StandardRouteHandler>(
            path, Poco::Net::HTTPRequest::HTTP_PATCH, handler));
    }

    /**
     * @brief 添加HEAD路由
     * @param path 路由路径
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    Router &Head(const std::string &path, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<StandardRouteHandler>(
            path, Poco::Net::HTTPRequest::HTTP_HEAD, handler));
    }

    /**
     * @brief 添加OPTIONS路由
     * @param path 路由路径
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    Router &Options(const std::string &path, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<StandardRouteHandler>(
            path, Poco::Net::HTTPRequest::HTTP_OPTIONS, handler));
    }

    /**
     * @brief 添加TRACE路由
     * @param path 路由路径
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    Router &Trace(const std::string &path, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<StandardRouteHandler>(
            path, Poco::Net::HTTPRequest::HTTP_TRACE, handler));
    }

    /**
     * @brief 添加GET正则路由
     * @param regex 路由正则表达式
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    Router &RegexGet(const std::string &regex, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<RegexRouteHandler>(
            regex, Poco::Net::HTTPRequest::HTTP_GET, handler));
    }

    /**
     * @brief 添加POST正则路由
     * @param regex 路由正则表达式
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    Router &RegexPost(const std::string &regex, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<RegexRouteHandler>(
            regex, Poco::Net::HTTPRequest::HTTP_POST, handler));
    }

    /**
     * @brief 添加PUT正则路由
     * @param regex 路由正则表达式
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    Router &RegexPut(const std::string &regex, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<RegexRouteHandler>(
            regex, Poco::Net::HTTPRequest::HTTP_PUT, handler));
    }

    /**
     * @brief 添加DELETE正则路由
     * @param regex 路由正则表达式
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    Router &RegexDelete(const std::string &regex, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<RegexRouteHandler>(
            regex, Poco::Net::HTTPRequest::HTTP_DELETE, handler));
    }

    /**
     * @brief 添加PATCH正则路由
     * @param regex 路由正则表达式
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    Router &RegexPatch(const std::string &regex, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<RegexRouteHandler>(
            regex, Poco::Net::HTTPRequest::HTTP_PATCH, handler));
    }

    /**
     * @brief 添加HEAD正则路由
     * @param regex 路由正则表达式
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    Router &RegexHead(const std::string &regex, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<RegexRouteHandler>(
            regex, Poco::Net::HTTPRequest::HTTP_HEAD, handler));
    }

    /**
     * @brief 添加OPTIONS正则路由
     * @param regex 路由正则表达式
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    Router &RegexOptions(const std::string &regex, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<RegexRouteHandler>(
            regex, Poco::Net::HTTPRequest::HTTP_OPTIONS, handler));
    }

    /**
     * @brief 添加TRACE正则路由
     * @param regex 路由正则表达式
     * @param handler 路由处理函数
     * @return 当前对象的引用，支持链式调用
     */
    Router &RegexTrace(const std::string &regex, const RouteHandlerFunc &handler)
    {
        return addHandler(std::make_shared<RegexRouteHandler>(
            regex, Poco::Net::HTTPRequest::HTTP_TRACE, handler));
    }

    Router();                                   ///< 私有构造函数
private:
    Router(const Router &) = delete;            ///< 禁止拷贝构造
    Router &operator=(const Router &) = delete; ///< 禁止赋值操作

    std::vector<std::shared_ptr<IRouteHandler>> m_handlers; ///< 路由处理器列表
    std::vector<MiddlewareHandler> m_middlewares;           ///< 全局中间件列表
    std::vector<RouteGroup> m_groups;                       ///< 路由组列表
    std::shared_ptr<IRouteHandler> m_notFoundHandler;       ///< 404处理器
    std::shared_ptr<IRouteHandler> m_errorHandler;          ///< 错误处理器

    /**
     * @brief 执行中间件链
     * @param middlewares 中间件列表
     * @param context 请求上下文
     * @return 如果所有中间件执行成功返回true，否则返回false
     */
    bool executeMiddlewareChain(const std::vector<MiddlewareHandler> &middlewares,
                                RequestContext &context);

    /**
     * @brief 查找匹配的路由处理器
     * @param context 请求上下文
     * @return 匹配的路由处理器，如果没有匹配返回nullptr
     */
    std::shared_ptr<IRouteHandler> findMatchingHandler(RequestContext &context);

private:
    Poco::Logger* _pLogger{ nullptr };
	CLink::Db::DatabaseManager::Ptr _dbManager{ nullptr }; ///< 数据库管理器指针
};

} // namespace Router
} // namespace CLink

#endif // CLINK_ROUTER_ROUTER_H